home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Turnbull China Bikeride
/
Turnbull China Bikeride - Disc 2.iso
/
STUTTGART
/
LANG
/
PROLOG
/
BP330
/
!BinPro330
/
progs
/
high
< prev
next >
Wrap
Text File
|
1995-02-06
|
3KB
|
131 lines
go:-foldl(+,0,[1,2,3],R),write(R),nl.
% fold,foldl based on safe failure driven destructive change_arg
foldl(Closure,Null,List,Final):-fold(Closure,Null,X^member(X,List),Final).
fold(Closure,Null,I^Generator,Final):-
fold0(s(Null),I,Generator,Closure,Final).
fold0(Acc,I,Generator,Closure,_):-
term_append(Closure,args(SoFar,I,O),Selector),
Generator,
arg(1,Acc,SoFar),
Selector,
change_arg(1,Acc,O),
fail.
fold0(Acc,_,_,_,Final):-
arg(1,Acc,Final).
% new version of bestof
best_of(X^Generator,TotalOrder,Bottom,Result):-
term_append(TotalOrder,args(X,Y),Test),
fold(compare_closure(Y,Test),Bottom,X^Generator,Result).
% map with updates on place
map(Closure,Xs):-
term_append(Closure,args(I,O),Goal),
update_on_place(Xs,I,O,Goal),
fail.
map(_,_).
update_on_place(Xs,I,O,Goal):-
Xs=[I|_],
Goal,
change_arg(1,Xs,O).
update_on_place([_|Xs],I,O,Goal):-
update_on_place(Xs,I,O,Goal).
% gives the illusion of a parallel engine
% works only with goals generating a finite stream of solutions
test_engine:-
open_engine(X,(X=1;X=2;X=3),E),
ask_engine(E,A),
ask_engine(E,B),
close_engine(E),
ask_engine(E,C),
ask_engine(E,D),
write([A,B,C,D]),nl.
open_engine(X,G,'$answers'(Gs)):-findall(X,G,Gs).
ask_engine('$answers'([]),X):-!,X='$empty'.
ask_engine(E,'$answer'(X)):-E='$answers'([X|Xs]),setarg(1,E,Xs).
close_engine(Engine):-setarg(1,Engine,[]).
/************************* maplist/3 ****************************/
% maps a Closure to a list and collects the results
%
% ex: ?-maplist(+(1),[10,20,30],Xs).
%
maplist(Closure,Is,Os):-maplist(Closure,Is,Os,[]).
maplist(Closure,Is,Os,End):-
term_append(Closure,args(I,O),Test),
findall(O,member_test(Test,I,Is),Os,End).
member_test(Test,I,[I|_]):-Test.
member_test(Test,I,[_|Is]):-member_test(Test,I,Is).
/************************* find/4 ****************************/
% combines 2 by 2 using Closure the selected answers I of Generator
% accumulating in Final the overall result
%
% ex: ?-find(member(X,[10,20,30]),+,X,Sum).
%
find(Generator,Closure,I,Final):-
term_append(Closure,args(SoFar,I,O),Selector),
find0(SoFar,I,O,Generator,Selector,Final).
find0(SoFar,I,O,Generator,Selector,_):-
inc_level(find,Level),
Generator,
select_or_init(Selector,Level,SoFar,I,O),
fail.
find0(_,_,_,_,_,Final):-
dec_level(find,Level),
bb_val(find,Level,Final),
rm(find,Level).
select_or_init(Selector,Level,SoFar,_,O):-
bb_val(find,Level,SoFar),!,
Selector,
bb_set(find,Level,O).
select_or_init(_,Level,_,I,_):-
bb_def(find,Level,I).
% ensure correct implementation of embedded calls to find/4
inc_level(Obj,X1):-bb_val(Obj,Obj,X),!,X1 is X+1,bb_set(Obj,Obj,X1).
inc_level(Obj,1):-bb_def(Obj,Obj,1).
dec_level(Obj,X):-bb_val(Obj,Obj,X),X>0,X1 is X-1,bb_set(Obj,Obj,X1).
/************************* scan/3 ****************************/
% Scans a list accumulating the results of applyng Closure on
% the elements of the list
%
% ex: ?-scan(+,[10,20,30],Sum).
%
scan(Closure,List,Result):-find(member(X,List),Closure,X,Result).
% X is the best answer of G with respect to TotalOrder (a closure)
%
% ex: ?-bestof(X,>,member(X,[3,2,9,1,5,4]).
%
bestof(X,TotalOrder,Generator):-
term_append(TotalOrder,args(X,Y),Test),
find(Generator,compare_closure(Y,Test),X,X).
compare_closure(Y,Test,Y,X,R):-Test,!,R=X.
compare_closure(_,_,Y,_,Y).